home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / despereaux-swings.swf / scripts / Box2D / Dynamics / b2Body.as next >
Encoding:
Text File  |  2011-10-17  |  19.6 KB  |  710 lines
  1. package Box2D.Dynamics
  2. {
  3.    import Box2D.Collision.Shapes.b2MassData;
  4.    import Box2D.Collision.Shapes.b2Shape;
  5.    import Box2D.Collision.Shapes.b2ShapeDef;
  6.    import Box2D.Common.Math.b2Mat22;
  7.    import Box2D.Common.Math.b2Math;
  8.    import Box2D.Common.Math.b2Sweep;
  9.    import Box2D.Common.Math.b2Vec2;
  10.    import Box2D.Common.Math.b2XForm;
  11.    import Box2D.Dynamics.Contacts.b2ContactEdge;
  12.    import Box2D.Dynamics.Joints.b2JointEdge;
  13.    
  14.    public class b2Body
  15.    {
  16.       
  17.       public static var e_fixedRotationFlag:uint = 64;
  18.       
  19.       public static var e_frozenFlag:uint = 2;
  20.       
  21.       public static var e_maxTypes:uint = 3;
  22.       
  23.       public static var e_sleepFlag:uint = 8;
  24.       
  25.       private static var s_massData:b2MassData = new b2MassData();
  26.       
  27.       public static var e_bulletFlag:uint = 32;
  28.       
  29.       public static var e_staticType:uint = 1;
  30.       
  31.       public static var e_islandFlag:uint = 4;
  32.       
  33.       public static var e_allowSleepFlag:uint = 16;
  34.       
  35.       private static var s_xf1:b2XForm = new b2XForm();
  36.       
  37.       public static var e_dynamicType:uint = 2;
  38.        
  39.       
  40.       public var m_next:b2Body;
  41.       
  42.       public var m_contactList:b2ContactEdge;
  43.       
  44.       public var m_angularVelocity:Number;
  45.       
  46.       public var m_shapeList:b2Shape;
  47.       
  48.       public var m_force:b2Vec2;
  49.       
  50.       public var m_mass:Number;
  51.       
  52.       public var m_sweep:b2Sweep;
  53.       
  54.       public var m_xf:b2XForm;
  55.       
  56.       public var m_torque:Number;
  57.       
  58.       public var m_userData:*;
  59.       
  60.       public var m_flags:uint;
  61.       
  62.       public var m_world:b2World;
  63.       
  64.       public var m_prev:b2Body;
  65.       
  66.       public var m_invMass:Number;
  67.       
  68.       public var m_type:int;
  69.       
  70.       public var m_linearDamping:Number;
  71.       
  72.       public var m_angularDamping:Number;
  73.       
  74.       public var m_invI:Number;
  75.       
  76.       public var m_linearVelocity:b2Vec2;
  77.       
  78.       public var m_sleepTime:Number;
  79.       
  80.       public var m_shapeCount:int;
  81.       
  82.       public var m_jointList:b2JointEdge;
  83.       
  84.       public var m_I:Number;
  85.       
  86.       public function b2Body(param1:b2BodyDef, param2:b2World)
  87.       {
  88.          var _loc3_:b2Mat22 = null;
  89.          var _loc4_:b2Vec2 = null;
  90.          m_xf = new b2XForm();
  91.          m_sweep = new b2Sweep();
  92.          m_linearVelocity = new b2Vec2();
  93.          m_force = new b2Vec2();
  94.          super();
  95.          m_flags = 0;
  96.          if(param1.isBullet)
  97.          {
  98.             m_flags |= e_bulletFlag;
  99.          }
  100.          if(param1.fixedRotation)
  101.          {
  102.             m_flags |= e_fixedRotationFlag;
  103.          }
  104.          if(param1.allowSleep)
  105.          {
  106.             m_flags |= e_allowSleepFlag;
  107.          }
  108.          if(param1.isSleeping)
  109.          {
  110.             m_flags |= e_sleepFlag;
  111.          }
  112.          m_world = param2;
  113.          m_xf.position.SetV(param1.position);
  114.          m_xf.R.Set(param1.angle);
  115.          m_sweep.localCenter.SetV(param1.massData.center);
  116.          m_sweep.t0 = 1;
  117.          m_sweep.a0 = m_sweep.a = param1.angle;
  118.          _loc3_ = m_xf.R;
  119.          _loc4_ = m_sweep.localCenter;
  120.          m_sweep.c.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  121.          m_sweep.c.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  122.          m_sweep.c.x += m_xf.position.x;
  123.          m_sweep.c.y += m_xf.position.y;
  124.          m_sweep.c0.SetV(m_sweep.c);
  125.          m_jointList = null;
  126.          m_contactList = null;
  127.          m_prev = null;
  128.          m_next = null;
  129.          m_linearDamping = param1.linearDamping;
  130.          m_angularDamping = param1.angularDamping;
  131.          m_force.Set(0,0);
  132.          m_torque = 0;
  133.          m_linearVelocity.SetZero();
  134.          m_angularVelocity = 0;
  135.          m_sleepTime = 0;
  136.          m_invMass = 0;
  137.          m_I = 0;
  138.          m_invI = 0;
  139.          m_mass = param1.massData.mass;
  140.          if(m_mass > 0)
  141.          {
  142.             m_invMass = 1 / m_mass;
  143.          }
  144.          if((m_flags & b2Body.e_fixedRotationFlag) == 0)
  145.          {
  146.             m_I = param1.massData.I;
  147.          }
  148.          if(m_I > 0)
  149.          {
  150.             m_invI = 1 / m_I;
  151.          }
  152.          if(m_invMass == 0 && m_invI == 0)
  153.          {
  154.             m_type = e_staticType;
  155.          }
  156.          else
  157.          {
  158.             m_type = e_dynamicType;
  159.          }
  160.          m_userData = param1.userData;
  161.          m_shapeList = null;
  162.          m_shapeCount = 0;
  163.       }
  164.       
  165.       public function GetLinearVelocityFromWorldPoint(param1:b2Vec2) : b2Vec2
  166.       {
  167.          return new b2Vec2(m_linearVelocity.x + m_angularVelocity * (param1.y - m_sweep.c.y),m_linearVelocity.x - m_angularVelocity * (param1.x - m_sweep.c.x));
  168.       }
  169.       
  170.       public function SetLinearVelocity(param1:b2Vec2) : void
  171.       {
  172.          m_linearVelocity.SetV(param1);
  173.       }
  174.       
  175.       public function WakeUp() : void
  176.       {
  177.          m_flags &= ~e_sleepFlag;
  178.          m_sleepTime = 0;
  179.       }
  180.       
  181.       public function GetLocalCenter() : b2Vec2
  182.       {
  183.          return m_sweep.localCenter;
  184.       }
  185.       
  186.       public function ApplyTorque(param1:Number) : void
  187.       {
  188.          if(IsSleeping())
  189.          {
  190.             WakeUp();
  191.          }
  192.          m_torque += param1;
  193.       }
  194.       
  195.       public function IsFrozen() : Boolean
  196.       {
  197.          return (m_flags & e_frozenFlag) == e_frozenFlag;
  198.       }
  199.       
  200.       public function IsDynamic() : Boolean
  201.       {
  202.          return m_type == e_dynamicType;
  203.       }
  204.       
  205.       public function GetLinearVelocity() : b2Vec2
  206.       {
  207.          return m_linearVelocity;
  208.       }
  209.       
  210.       public function SynchronizeTransform() : void
  211.       {
  212.          var _loc1_:b2Mat22 = null;
  213.          var _loc2_:b2Vec2 = null;
  214.          m_xf.R.Set(m_sweep.a);
  215.          _loc1_ = m_xf.R;
  216.          _loc2_ = m_sweep.localCenter;
  217.          m_xf.position.x = m_sweep.c.x - (_loc1_.col1.x * _loc2_.x + _loc1_.col2.x * _loc2_.y);
  218.          m_xf.position.y = m_sweep.c.y - (_loc1_.col1.y * _loc2_.x + _loc1_.col2.y * _loc2_.y);
  219.       }
  220.       
  221.       public function GetInertia() : Number
  222.       {
  223.          return m_I;
  224.       }
  225.       
  226.       public function IsSleeping() : Boolean
  227.       {
  228.          return (m_flags & e_sleepFlag) == e_sleepFlag;
  229.       }
  230.       
  231.       public function SetMassFromShapes() : void
  232.       {
  233.          var _loc1_:b2Shape = null;
  234.          var _loc2_:Number = NaN;
  235.          var _loc3_:Number = NaN;
  236.          var _loc4_:b2MassData = null;
  237.          var _loc5_:b2Mat22 = null;
  238.          var _loc6_:b2Vec2 = null;
  239.          var _loc7_:int = 0;
  240.          if(m_world.m_lock == true)
  241.          {
  242.             return;
  243.          }
  244.          m_mass = 0;
  245.          m_invMass = 0;
  246.          m_I = 0;
  247.          m_invI = 0;
  248.          _loc2_ = 0;
  249.          _loc3_ = 0;
  250.          _loc4_ = s_massData;
  251.          _loc1_ = m_shapeList;
  252.          while(_loc1_)
  253.          {
  254.             _loc1_.ComputeMass(_loc4_);
  255.             m_mass += _loc4_.mass;
  256.             _loc2_ += _loc4_.mass * _loc4_.center.x;
  257.             _loc3_ += _loc4_.mass * _loc4_.center.y;
  258.             m_I += _loc4_.I;
  259.             _loc1_ = _loc1_.m_next;
  260.          }
  261.          if(m_mass > 0)
  262.          {
  263.             m_invMass = 1 / m_mass;
  264.             _loc2_ *= m_invMass;
  265.             _loc3_ *= m_invMass;
  266.          }
  267.          if(m_I > 0 && (m_flags & e_fixedRotationFlag) == 0)
  268.          {
  269.             m_I -= m_mass * (_loc2_ * _loc2_ + _loc3_ * _loc3_);
  270.             m_invI = 1 / m_I;
  271.          }
  272.          else
  273.          {
  274.             m_I = 0;
  275.             m_invI = 0;
  276.          }
  277.          m_sweep.localCenter.Set(_loc2_,_loc3_);
  278.          _loc5_ = m_xf.R;
  279.          _loc6_ = m_sweep.localCenter;
  280.          m_sweep.c.x = _loc5_.col1.x * _loc6_.x + _loc5_.col2.x * _loc6_.y;
  281.          m_sweep.c.y = _loc5_.col1.y * _loc6_.x + _loc5_.col2.y * _loc6_.y;
  282.          m_sweep.c.x += m_xf.position.x;
  283.          m_sweep.c.y += m_xf.position.y;
  284.          m_sweep.c0.SetV(m_sweep.c);
  285.          _loc1_ = m_shapeList;
  286.          while(_loc1_)
  287.          {
  288.             _loc1_.UpdateSweepRadius(m_sweep.localCenter);
  289.             _loc1_ = _loc1_.m_next;
  290.          }
  291.          _loc7_ = m_type;
  292.          if(m_invMass == 0 && m_invI == 0)
  293.          {
  294.             m_type = e_staticType;
  295.          }
  296.          else
  297.          {
  298.             m_type = e_dynamicType;
  299.          }
  300.          if(_loc7_ != m_type)
  301.          {
  302.             _loc1_ = m_shapeList;
  303.             while(_loc1_)
  304.             {
  305.                _loc1_.RefilterProxy(m_world.m_broadPhase,m_xf);
  306.                _loc1_ = _loc1_.m_next;
  307.             }
  308.          }
  309.       }
  310.       
  311.       public function PutToSleep() : void
  312.       {
  313.          m_flags |= e_sleepFlag;
  314.          m_sleepTime = 0;
  315.          m_linearVelocity.SetZero();
  316.          m_angularVelocity = 0;
  317.          m_force.SetZero();
  318.          m_torque = 0;
  319.       }
  320.       
  321.       public function GetJointList() : b2JointEdge
  322.       {
  323.          return m_jointList;
  324.       }
  325.       
  326.       public function SetXForm(param1:b2Vec2, param2:Number) : Boolean
  327.       {
  328.          var _loc3_:b2Shape = null;
  329.          var _loc4_:b2Mat22 = null;
  330.          var _loc5_:b2Vec2 = null;
  331.          var _loc6_:Boolean = false;
  332.          var _loc7_:Boolean = false;
  333.          if(m_world.m_lock == true)
  334.          {
  335.             return true;
  336.          }
  337.          if(IsFrozen())
  338.          {
  339.             return false;
  340.          }
  341.          m_xf.R.Set(param2);
  342.          m_xf.position.SetV(param1);
  343.          _loc4_ = m_xf.R;
  344.          _loc5_ = m_sweep.localCenter;
  345.          m_sweep.c.x = _loc4_.col1.x * _loc5_.x + _loc4_.col2.x * _loc5_.y;
  346.          m_sweep.c.y = _loc4_.col1.y * _loc5_.x + _loc4_.col2.y * _loc5_.y;
  347.          m_sweep.c.x += m_xf.position.x;
  348.          m_sweep.c.y += m_xf.position.y;
  349.          m_sweep.c0.SetV(m_sweep.c);
  350.          m_sweep.a0 = m_sweep.a = param2;
  351.          _loc6_ = false;
  352.          _loc3_ = m_shapeList;
  353.          while(_loc3_)
  354.          {
  355.             if((_loc7_ = _loc3_.Synchronize(m_world.m_broadPhase,m_xf,m_xf)) == false)
  356.             {
  357.                _loc6_ = true;
  358.                break;
  359.             }
  360.             _loc3_ = _loc3_.m_next;
  361.          }
  362.          if(_loc6_ == true)
  363.          {
  364.             m_flags |= e_frozenFlag;
  365.             m_linearVelocity.SetZero();
  366.             m_angularVelocity = 0;
  367.             _loc3_ = m_shapeList;
  368.             while(_loc3_)
  369.             {
  370.                _loc3_.DestroyProxy(m_world.m_broadPhase);
  371.                _loc3_ = _loc3_.m_next;
  372.             }
  373.             return false;
  374.          }
  375.          m_world.m_broadPhase.Commit();
  376.          return true;
  377.       }
  378.       
  379.       public function GetLocalPoint(param1:b2Vec2) : b2Vec2
  380.       {
  381.          return b2Math.b2MulXT(m_xf,param1);
  382.       }
  383.       
  384.       public function ApplyForce(param1:b2Vec2, param2:b2Vec2) : void
  385.       {
  386.          if(IsSleeping())
  387.          {
  388.             WakeUp();
  389.          }
  390.          m_force.x += param1.x;
  391.          m_force.y += param1.y;
  392.          m_torque += (param2.x - m_sweep.c.x) * param1.y - (param2.y - m_sweep.c.y) * param1.x;
  393.       }
  394.       
  395.       public function SynchronizeShapes() : Boolean
  396.       {
  397.          var _loc1_:b2XForm = null;
  398.          var _loc2_:b2Mat22 = null;
  399.          var _loc3_:b2Vec2 = null;
  400.          var _loc4_:b2Shape = null;
  401.          var _loc5_:Boolean = false;
  402.          _loc1_ = s_xf1;
  403.          _loc1_.R.Set(m_sweep.a0);
  404.          _loc2_ = _loc1_.R;
  405.          _loc3_ = m_sweep.localCenter;
  406.          _loc1_.position.x = m_sweep.c0.x - (_loc2_.col1.x * _loc3_.x + _loc2_.col2.x * _loc3_.y);
  407.          _loc1_.position.y = m_sweep.c0.y - (_loc2_.col1.y * _loc3_.x + _loc2_.col2.y * _loc3_.y);
  408.          _loc5_ = true;
  409.          _loc4_ = m_shapeList;
  410.          while(_loc4_)
  411.          {
  412.             if((_loc5_ = _loc4_.Synchronize(m_world.m_broadPhase,_loc1_,m_xf)) == false)
  413.             {
  414.                break;
  415.             }
  416.             _loc4_ = _loc4_.m_next;
  417.          }
  418.          if(_loc5_ == false)
  419.          {
  420.             m_flags |= e_frozenFlag;
  421.             m_linearVelocity.SetZero();
  422.             m_angularVelocity = 0;
  423.             _loc4_ = m_shapeList;
  424.             while(_loc4_)
  425.             {
  426.                _loc4_.DestroyProxy(m_world.m_broadPhase);
  427.                _loc4_ = _loc4_.m_next;
  428.             }
  429.             return false;
  430.          }
  431.          return true;
  432.       }
  433.       
  434.       public function GetAngle() : Number
  435.       {
  436.          return m_sweep.a;
  437.       }
  438.       
  439.       public function GetXForm() : b2XForm
  440.       {
  441.          return m_xf;
  442.       }
  443.       
  444.       public function ApplyImpulse(param1:b2Vec2, param2:b2Vec2) : void
  445.       {
  446.          if(IsSleeping())
  447.          {
  448.             WakeUp();
  449.          }
  450.          m_linearVelocity.x += m_invMass * param1.x;
  451.          m_linearVelocity.y += m_invMass * param1.y;
  452.          m_angularVelocity += m_invI * ((param2.x - m_sweep.c.x) * param1.y - (param2.y - m_sweep.c.y) * param1.x);
  453.       }
  454.       
  455.       public function GetNext() : b2Body
  456.       {
  457.          return m_next;
  458.       }
  459.       
  460.       public function GetMass() : Number
  461.       {
  462.          return m_mass;
  463.       }
  464.       
  465.       public function GetLinearVelocityFromLocalPoint(param1:b2Vec2) : b2Vec2
  466.       {
  467.          var _loc2_:b2Mat22 = null;
  468.          var _loc3_:b2Vec2 = null;
  469.          _loc2_ = m_xf.R;
  470.          _loc3_ = new b2Vec2(_loc2_.col1.x * param1.x + _loc2_.col2.x * param1.y,_loc2_.col1.y * param1.x + _loc2_.col2.y * param1.y);
  471.          _loc3_.x += m_xf.position.x;
  472.          _loc3_.y += m_xf.position.y;
  473.          return new b2Vec2(m_linearVelocity.x + m_angularVelocity * (_loc3_.y - m_sweep.c.y),m_linearVelocity.x - m_angularVelocity * (_loc3_.x - m_sweep.c.x));
  474.       }
  475.       
  476.       public function GetAngularVelocity() : Number
  477.       {
  478.          return m_angularVelocity;
  479.       }
  480.       
  481.       public function SetAngularVelocity(param1:Number) : void
  482.       {
  483.          m_angularVelocity = param1;
  484.       }
  485.       
  486.       public function SetMass(param1:b2MassData) : void
  487.       {
  488.          var _loc2_:b2Shape = null;
  489.          var _loc3_:b2Mat22 = null;
  490.          var _loc4_:b2Vec2 = null;
  491.          var _loc5_:int = 0;
  492.          if(m_world.m_lock == true)
  493.          {
  494.             return;
  495.          }
  496.          m_invMass = 0;
  497.          m_I = 0;
  498.          m_invI = 0;
  499.          m_mass = param1.mass;
  500.          if(m_mass > 0)
  501.          {
  502.             m_invMass = 1 / m_mass;
  503.          }
  504.          if((m_flags & b2Body.e_fixedRotationFlag) == 0)
  505.          {
  506.             m_I = param1.I;
  507.          }
  508.          if(m_I > 0)
  509.          {
  510.             m_invI = 1 / m_I;
  511.          }
  512.          m_sweep.localCenter.SetV(param1.center);
  513.          _loc3_ = m_xf.R;
  514.          _loc4_ = m_sweep.localCenter;
  515.          m_sweep.c.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  516.          m_sweep.c.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  517.          m_sweep.c.x += m_xf.position.x;
  518.          m_sweep.c.y += m_xf.position.y;
  519.          m_sweep.c0.SetV(m_sweep.c);
  520.          _loc2_ = m_shapeList;
  521.          while(_loc2_)
  522.          {
  523.             _loc2_.UpdateSweepRadius(m_sweep.localCenter);
  524.             _loc2_ = _loc2_.m_next;
  525.          }
  526.          _loc5_ = m_type;
  527.          if(m_invMass == 0 && m_invI == 0)
  528.          {
  529.             m_type = e_staticType;
  530.          }
  531.          else
  532.          {
  533.             m_type = e_dynamicType;
  534.          }
  535.          if(_loc5_ != m_type)
  536.          {
  537.             _loc2_ = m_shapeList;
  538.             while(_loc2_)
  539.             {
  540.                _loc2_.RefilterProxy(m_world.m_broadPhase,m_xf);
  541.                _loc2_ = _loc2_.m_next;
  542.             }
  543.          }
  544.       }
  545.       
  546.       public function IsStatic() : Boolean
  547.       {
  548.          return m_type == e_staticType;
  549.       }
  550.       
  551.       public function GetWorldVector(param1:b2Vec2) : b2Vec2
  552.       {
  553.          return b2Math.b2MulMV(m_xf.R,param1);
  554.       }
  555.       
  556.       public function GetShapeList() : b2Shape
  557.       {
  558.          return m_shapeList;
  559.       }
  560.       
  561.       public function Advance(param1:Number) : void
  562.       {
  563.          m_sweep.Advance(param1);
  564.          m_sweep.c.SetV(m_sweep.c0);
  565.          m_sweep.a = m_sweep.a0;
  566.          SynchronizeTransform();
  567.       }
  568.       
  569.       public function SetBullet(param1:Boolean) : void
  570.       {
  571.          if(param1)
  572.          {
  573.             m_flags |= e_bulletFlag;
  574.          }
  575.          else
  576.          {
  577.             m_flags &= ~e_bulletFlag;
  578.          }
  579.       }
  580.       
  581.       public function CreateShape(param1:b2ShapeDef) : b2Shape
  582.       {
  583.          var _loc2_:b2Shape = null;
  584.          if(m_world.m_lock == true)
  585.          {
  586.             return null;
  587.          }
  588.          _loc2_ = b2Shape.Create(param1,m_world.m_blockAllocator);
  589.          _loc2_.m_next = m_shapeList;
  590.          m_shapeList = _loc2_;
  591.          ++m_shapeCount;
  592.          _loc2_.m_body = this;
  593.          _loc2_.CreateProxy(m_world.m_broadPhase,m_xf);
  594.          _loc2_.UpdateSweepRadius(m_sweep.localCenter);
  595.          return _loc2_;
  596.       }
  597.       
  598.       public function IsConnected(param1:b2Body) : Boolean
  599.       {
  600.          var _loc2_:b2JointEdge = null;
  601.          _loc2_ = m_jointList;
  602.          while(_loc2_)
  603.          {
  604.             if(_loc2_.other == param1)
  605.             {
  606.                return _loc2_.joint.m_collideConnected == false;
  607.             }
  608.             _loc2_ = _loc2_.next;
  609.          }
  610.          return false;
  611.       }
  612.       
  613.       public function DestroyShape(param1:b2Shape) : void
  614.       {
  615.          var _loc2_:b2Shape = null;
  616.          var _loc3_:b2Shape = null;
  617.          var _loc4_:Boolean = false;
  618.          if(m_world.m_lock == true)
  619.          {
  620.             return;
  621.          }
  622.          param1.DestroyProxy(m_world.m_broadPhase);
  623.          _loc2_ = m_shapeList;
  624.          _loc3_ = null;
  625.          _loc4_ = false;
  626.          while(_loc2_ != null)
  627.          {
  628.             if(_loc2_ == param1)
  629.             {
  630.                if(_loc3_)
  631.                {
  632.                   _loc3_.m_next = param1.m_next;
  633.                }
  634.                else
  635.                {
  636.                   m_shapeList = param1.m_next;
  637.                }
  638.                _loc4_ = true;
  639.                break;
  640.             }
  641.             _loc3_ = _loc2_;
  642.             _loc2_ = _loc2_.m_next;
  643.          }
  644.          param1.m_body = null;
  645.          param1.m_next = null;
  646.          --m_shapeCount;
  647.          b2Shape.Destroy(param1,m_world.m_blockAllocator);
  648.       }
  649.       
  650.       public function GetUserData() : *
  651.       {
  652.          return m_userData;
  653.       }
  654.       
  655.       public function IsBullet() : Boolean
  656.       {
  657.          return (m_flags & e_bulletFlag) == e_bulletFlag;
  658.       }
  659.       
  660.       public function GetWorldCenter() : b2Vec2
  661.       {
  662.          return m_sweep.c;
  663.       }
  664.       
  665.       public function AllowSleeping(param1:Boolean) : void
  666.       {
  667.          if(param1)
  668.          {
  669.             m_flags |= e_allowSleepFlag;
  670.          }
  671.          else
  672.          {
  673.             m_flags &= ~e_allowSleepFlag;
  674.             WakeUp();
  675.          }
  676.       }
  677.       
  678.       public function SetUserData(param1:*) : void
  679.       {
  680.          m_userData = param1;
  681.       }
  682.       
  683.       public function GetLocalVector(param1:b2Vec2) : b2Vec2
  684.       {
  685.          return b2Math.b2MulTMV(m_xf.R,param1);
  686.       }
  687.       
  688.       public function GetWorldPoint(param1:b2Vec2) : b2Vec2
  689.       {
  690.          var _loc2_:b2Mat22 = null;
  691.          var _loc3_:b2Vec2 = null;
  692.          _loc2_ = m_xf.R;
  693.          _loc3_ = new b2Vec2(_loc2_.col1.x * param1.x + _loc2_.col2.x * param1.y,_loc2_.col1.y * param1.x + _loc2_.col2.y * param1.y);
  694.          _loc3_.x += m_xf.position.x;
  695.          _loc3_.y += m_xf.position.y;
  696.          return _loc3_;
  697.       }
  698.       
  699.       public function GetWorld() : b2World
  700.       {
  701.          return m_world;
  702.       }
  703.       
  704.       public function GetPosition() : b2Vec2
  705.       {
  706.          return m_xf.position;
  707.       }
  708.    }
  709. }
  710.